From c31b849d18b86a1d8e693ba8caa47725f1ea05a5 Mon Sep 17 00:00:00 2001 From: "mjw@wray-m-3.hpl.hp.com" Date: Mon, 23 Aug 2004 12:28:30 +0000 Subject: [PATCH] bitkeeper revision 1.1159.50.1 (4129e2eeyO6KrwYWOMXPMAjegVEpTA) Restructure code dealing with backends to use a backend controller and separate backend interfaces on each front-end domain. --- tools/python/xen/xend/XendDomainInfo.py | 6 +- tools/python/xen/xend/server/SrvDaemon.py | 38 +-- tools/python/xen/xend/server/blkif.py | 81 ++++--- tools/python/xen/xend/server/console.py | 8 +- tools/python/xen/xend/server/controller.py | 257 +++++++++++++++------ tools/python/xen/xend/server/domain.py | 20 +- tools/python/xen/xend/server/netif.py | 67 ++++-- 7 files changed, 312 insertions(+), 165 deletions(-) diff --git a/tools/python/xen/xend/XendDomainInfo.py b/tools/python/xen/xend/XendDomainInfo.py index f394bdee66..dabcb68e7e 100644 --- a/tools/python/xen/xend/XendDomainInfo.py +++ b/tools/python/xen/xend/XendDomainInfo.py @@ -948,7 +948,7 @@ class XendDomainInfo: @return: deferred """ ctrl = xend.blkif_create(self.dom, recreate=self.recreate) - back = ctrl.getBackend(0) + back = ctrl.getBackendInterface(0) return back.connect(recreate=self.recreate) def dom_construct(self, dom, config): @@ -1049,8 +1049,6 @@ def vm_dev_vif(vm, val, index): @param index: vif index @return: deferred """ - #if vm.netif_backend: - # raise VmError('vif: vif in netif backend domain') vif = vm.next_device_index('vif') vmac = sxp.child_value(val, "mac") ctrl = xend.netif_create(vm.dom, recreate=vm.recreate) @@ -1071,8 +1069,6 @@ def vm_dev_vbd(vm, val, index): @param index: vbd index @return: deferred """ - #if vm.blkif_backend: - # raise VmError('vbd: vbd in blkif backend domain') uname = sxp.child_value(val, 'uname') if not uname: raise VmError('vbd: Missing uname') diff --git a/tools/python/xen/xend/server/SrvDaemon.py b/tools/python/xen/xend/server/SrvDaemon.py index 2cf58db57a..55aa6567aa 100644 --- a/tools/python/xen/xend/server/SrvDaemon.py +++ b/tools/python/xen/xend/server/SrvDaemon.py @@ -374,6 +374,7 @@ class EventProtocol(protocol.Protocol): id = sxp.child_value(req, 'id') if not id: raise XendError('Missing console id') + id = int(id) self.daemon.console_disconnect(id) return ['ok'] @@ -652,17 +653,17 @@ class Daemon: return self.channelF.getDomChannel(dom) def blkif_create(self, dom, recreate=0): - """Create a block device interface controller. + """Create or get a block device interface controller. Returns controller """ - return self.blkifCF.createInstance(dom, recreate=recreate) + return self.blkifCF.getController(dom) def blkifs(self): - return [ x.sxpr() for x in self.blkifCF.getInstances() ] + return [ x.sxpr() for x in self.blkifCF.getControllers() ] def blkif_get(self, dom): - return self.blkifCF.getInstanceByDom(dom) + return self.blkifCF.getControllerByDom(dom) def blkif_dev(self, dom, vdev): return self.blkifCF.getDomainDevice(dom, vdev) @@ -672,29 +673,29 @@ class Daemon: Returns Deferred """ - ctrl = self.blkifCF.getInstanceByDom(dom) + ctrl = self.blkifCF.getControllerByDom(dom) if not ctrl: raise XendError('No blkif controller: %d' % dom) d = ctrl.attachDevice(config, vdev, mode, segment, recreate=recreate) return d def netif_create(self, dom, recreate=0): - """Create a network interface controller. + """Create or get a network interface controller. """ - return self.netifCF.createInstance(dom, recreate=recreate) + return self.netifCF.getController(dom) def netifs(self): - return [ x.sxpr() for x in self.netifCF.getInstances() ] + return [ x.sxpr() for x in self.netifCF.getControllers() ] def netif_get(self, dom): - return self.netifCF.getInstanceByDom(dom) + return self.netifCF.getControllerByDom(dom) def netif_dev_create(self, dom, vif, config, recreate=0): """Create a network device. """ - ctrl = self.netifCF.getInstanceByDom(dom) + ctrl = self.netifCF.getControllerByDom(dom) if not ctrl: raise XendError('No netif controller: %d' % dom) d = ctrl.attachDevice(vif, config, recreate=recreate) @@ -706,22 +707,22 @@ class Daemon: def console_create(self, dom, console_port=None): """Create a console for a domain. """ - console = self.consoleCF.getInstanceByDom(dom) + console = self.consoleCF.getControllerByDom(dom) if console is None: - console = self.consoleCF.createInstance(dom, console_port) + console = self.consoleCF.createController(dom, console_port) return console def consoles(self): - return [ c.sxpr() for c in self.consoleCF.getInstances() ] + return [ c.sxpr() for c in self.consoleCF.getControllers() ] def get_consoles(self): - return self.consoleCF.getInstances() + return self.consoleCF.getControllers() def get_console(self, id): - return self.consoleCF.getInstance(id) + return self.consoleCF.getControllerByIndex(id) def get_domain_console(self, dom): - return self.consoleCF.getInstanceByDom(dom) + return self.consoleCF.getControllerByDom(dom) def console_disconnect(self, id): """Disconnect any connected console client. @@ -734,9 +735,10 @@ class Daemon: def domain_shutdown(self, dom, reason): """Shutdown a domain. """ - ctrl = self.domainCF.getInstanceByDom(dom) + dom = int(dom) + ctrl = self.domainCF.getController(dom) if not ctrl: - raise XendError('No domain controller: %d' % dom) + raise XendError('No domain controller: %s' % dom) ctrl.shutdown(reason) return 0 diff --git a/tools/python/xen/xend/server/blkif.py b/tools/python/xen/xend/server/blkif.py index 00f19a805d..0f6f84b3cc 100755 --- a/tools/python/xen/xend/server/blkif.py +++ b/tools/python/xen/xend/server/blkif.py @@ -14,24 +14,16 @@ import controller from messages import * class BlkifBackendController(controller.BackendController): - """ Handler for the 'back-end' channel to a device driver domain. - Must be connected using connect() before it can be used. - Do not create directly - use getBackend() on the BlkifController. + """ Handler for the 'back-end' channel to a block device driver domain. """ - def __init__(self, ctrl, dom, handle): - controller.BackendController.__init__(self, ctrl, dom, handle) - self.connected = 0 - self.evtchn = None - self.handle = handle + def __init__(self, factory, dom): + controller.BackendController.__init__(self, factory, dom) self.addMethod(CMSG_BLKIF_BE, CMSG_BLKIF_BE_DRIVER_STATUS_CHANGED, self.recv_be_driver_status_changed) self.registerChannel() - def __str__(self): - return '' % (self.controller.dom, self.dom) - def recv_be_driver_status_changed(self, msg, req): """Request handler for be_driver_status_changed messages. @@ -43,8 +35,23 @@ class BlkifBackendController(controller.BackendController): val = unpackMsg('blkif_be_driver_status_changed_t', msg) status = val['status'] +class BlkifBackendInterface(controller.BackendInterface): + """ Handler for the 'back-end' channel to a block device driver domain + on behalf of a front-end domain. + Must be connected using connect() before it can be used. + Do not create directly - use getBackendInterface() on the BlkifController. + """ + + def __init__(self, ctrl, dom, handle): + controller.BackendInterface.__init__(self, ctrl, dom, handle) + self.connected = 0 + self.evtchn = None + + def __str__(self): + return '' % (self.controller.dom, self.dom) + def connect(self, recreate=0): - """Connect the controller to the blkif control interface. + """Connect to the blkif control interface. @param recreate: true if after xend restart @return: deferred @@ -76,6 +83,7 @@ class BlkifBackendController(controller.BackendController): """ def cb_destroy(val): self.send_be_destroy() + self.close() d = defer.Deferred() d.addCallback(cb_destroy) self.send_be_disconnect(response=d) @@ -124,14 +132,14 @@ class BlkifBackendController(controller.BackendController): 'evtchn' : self.evtchn['port2'] }) self.controller.writeRequest(msg, response=response) -class BlkifControllerFactory(controller.ControllerFactory): +class BlkifControllerFactory(controller.SplitControllerFactory): """Factory for creating block device interface controllers. """ def __init__(self): - controller.ControllerFactory.__init__(self) + controller.SplitControllerFactory.__init__(self) - def createInstance(self, dom, recreate=0): + def createController(self, dom, recreate=0): """Create a block device controller for a domain. @param dom: domain @@ -141,12 +149,30 @@ class BlkifControllerFactory(controller.ControllerFactory): @return: block device controller @rtype: BlkifController """ - blkif = self.getInstanceByDom(dom) + blkif = self.getControllerByDom(dom) if blkif is None: blkif = BlkifController(self, dom) - self.addInstance(blkif) + self.addController(blkif) return blkif + def createBackendController(self, dom): + """Create a block device backend controller. + + @param dom: backend domain + @return: backend controller + """ + return BlkifBackendController(self, dom) + + def createBackendInterface(self, ctrl, dom, handle): + """Create a block device backend interface. + + @param ctrl: controller + @param dom: backend domain + @param handle: interface handle + @return: backend interface + """ + return BlkifBackendInterface(ctrl, dom, handle) + def getDomainDevices(self, dom): """Get the block devices for a domain. @@ -155,7 +181,7 @@ class BlkifControllerFactory(controller.ControllerFactory): @return: devices @rtype: [device] """ - blkif = self.getInstanceByDom(dom) + blkif = self.getControllerByDom(dom) return (blkif and blkif.getDevices()) or [] def getDomainDevice(self, dom, vdev): @@ -168,7 +194,7 @@ class BlkifControllerFactory(controller.ControllerFactory): @return: device @rtype: device """ - blkif = self.getInstanceByDom(dom) + blkif = self.getControllerByDom(dom) return (blkif and blkif.getDevice(vdev)) or None class BlkDev(controller.SplitDev): @@ -213,7 +239,7 @@ class BlkDev(controller.SplitDev): """Attach the device to its controller. """ - backend = self.getBackend() + backend = self.getBackendInterface() d1 = backend.connect() d2 = defer.Deferred() d2.addCallback(self.send_be_vbd_create) @@ -223,7 +249,7 @@ class BlkDev(controller.SplitDev): def send_be_vbd_create(self, val): d = defer.Deferred() d.addCallback(self.respond_be_vbd_create) - backend = self.getBackend() + backend = self.getBackendInterface() msg = packMsg('blkif_be_vbd_create_t', { 'domid' : self.controller.dom, 'blkif_handle' : backend.handle, @@ -246,7 +272,7 @@ class BlkDev(controller.SplitDev): def send_be_vbd_grow(self): d = defer.Deferred() - backend = self.getBackend() + backend = self.getBackendInterface() msg = packMsg('blkif_be_vbd_grow_t', { 'domid' : self.controller.dom, 'blkif_handle' : backend.handle, @@ -273,7 +299,7 @@ class BlkDev(controller.SplitDev): def send_be_vbd_destroy(self, response=None): log.debug('>BlkDev>send_be_vbd_destroy> dom=%d vdev=%d', self.controller.dom, self.vdev) - backend = self.getBackend() + backend = self.getBackendInterface() msg = packMsg('blkif_be_vbd_destroy_t', { 'domid' : self.controller.dom, 'blkif_handle' : backend.handle, @@ -289,7 +315,7 @@ class BlkifController(controller.SplitController): def __init__(self, factory, dom): """Create a block device controller. - Do not call directly - use createInstance() on the factory instead. + Do not call directly - use createController() on the factory instead. """ controller.SplitController.__init__(self, factory, dom) self.devices = {} @@ -305,9 +331,6 @@ class BlkifController(controller.SplitController): val = ['blkif', ['dom', self.dom]] return val - def createBackend(self, dom, handle): - return BlkifBackendController(self, dom, handle) - def getDevices(self): return self.devices.values() @@ -372,7 +395,7 @@ class BlkifController(controller.SplitController): dev.destroy() def destroyBackends(self): - for backend in self.getBackends(): + for backend in self.getBackendInterfaces(): backend.destroy() def recv_fe_driver_status_changed(self, msg, req): @@ -388,7 +411,7 @@ class BlkifController(controller.SplitController): def recv_fe_interface_connect(self, msg, req): val = unpackMsg('blkif_fe_interface_connect_t', msg) handle = val['handle'] - backend = self.getBackendByHandle(handle) + backend = self.getBackendInterfaceByHandle(handle) if backend: backend.connectInterface(val) else: diff --git a/tools/python/xen/xend/server/console.py b/tools/python/xen/xend/server/console.py index df07528938..666ffca2ff 100755 --- a/tools/python/xen/xend/server/console.py +++ b/tools/python/xen/xend/server/console.py @@ -81,14 +81,14 @@ class ConsoleControllerFactory(controller.ControllerFactory): """Factory for creating console controllers. """ - def createInstance(self, dom, console_port=None): + def createController(self, dom, console_port=None): if console_port is None: console_port = CONSOLE_PORT_BASE + dom - for c in self.getInstances(): + for c in self.getControllers(): if c.console_port == console_port: raise XendError('console port in use: ' + str(console_port)) console = ConsoleController(self, dom, console_port) - self.addInstance(console) + self.addController(console) log.info("Created console id=%s domain=%d port=%d", console.idx, console.dom, console.console_port) eserver.inject('xend.console.create', @@ -98,7 +98,7 @@ class ConsoleControllerFactory(controller.ControllerFactory): def consoleClosed(self, console): log.info("Closed console id=%s", console.idx) eserver.inject('xend.console.close', console.idx) - self.delInstance(console) + self.delController(console) class ConsoleController(controller.Controller): """Console controller for a domain. diff --git a/tools/python/xen/xend/server/controller.py b/tools/python/xen/xend/server/controller.py index dd1a9e6ebe..d2628e8779 100755 --- a/tools/python/xen/xend/server/controller.py +++ b/tools/python/xen/xend/server/controller.py @@ -274,72 +274,80 @@ class CtrlMsgRcvr: class ControllerFactory: """Abstract class for factories creating controllers for a domain. - Maintains a table of instances. + Maintains a table of controllers. - @ivar instances: mapping of index to controller instance - @type instances: {String: Controller} + @ivar controllers: mapping of index to controller instance + @type controllers: {String: Controller} @ivar dom: domain @type dom: int """ def __init__(self): - self.instances = {} - self.backends = {} - self.dom = 0 + self.controllers = {} - def addInstance(self, instance): + def addController(self, controller): """Add a controller instance (under its index). """ - self.instances[instance.idx] = instance + self.controllers[controller.idx] = controller - def getInstance(self, idx): - """Get a controller instance from its index. + def getControllers(self): + """Get a list of all controllers. """ - return self.instances.get(idx) + return self.controllers.values() - def getInstances(self): - """Get a list of all controller instances. + def getControllerByIndex(self, idx): + """Get a controller from its index. """ - return self.instances.values() + return self.controllers.get(idx) - def getInstanceByDom(self, dom): - """Get the controller instance for the given domain. + def getControllerByDom(self, dom): + """Get the controller for the given domain. @param dom: domain id @type dom: int @return: controller or None """ - for inst in self.instances.values(): + for inst in self.controllers.values(): if inst.dom == dom: return inst return None - def delInstance(self, instance): - """Delete a controller instance from the table. + def getController(self, dom): + """Create or find the controller for a domain. - @param instance: controller instance + @param dom: domain + @return: controller """ - if instance.idx in self.instances: - del self.instances[instance.idx] - - def createInstance(self, dom, recreate=0): - """Create an instance. Define in a subclass. + ctrl = self.getControllerByDom(dom) + if ctrl is None: + ctrl = self.createController(dom) + self.addController(ctrl) + return ctrl + + def createController(self, dom): + """Create a controller. Define in a subclass. @param dom: domain @type dom: int - @param recreate: true if the instance is being recreated (after xend restart) - @type recreate: int @return: controller instance @rtype: Controller (or subclass) """ raise NotImplementedError() - def instanceClosed(self, instance): - """Callback called when an instance is closed (usually by the instance). + def delController(self, controller): + """Delete a controller instance from the table. + + @param controller: controller instance + """ + if controller.idx in self.controllers: + del self.controllers[controller.idx] + + def controllerClosed(self, controller): + """Callback called when a controller is closed (usually by the controller). - @param instance: controller instance + @param controller: controller instance """ - self.delInstance(instance) + self.delController(controller) class Controller(CtrlMsgRcvr): """Abstract class for a device controller attached to a domain. @@ -370,91 +378,204 @@ class Controller(CtrlMsgRcvr): """The controller channel has been lost. """ self.deregisterChannel() - self.factory.instanceClosed(self) + self.factory.controllerClosed(self) + +class SplitControllerFactory(ControllerFactory): + """Abstract class for factories creating split controllers for a domain. + Maintains a table of backend controllers. + """ + + def __init__(self): + ControllerFactory.__init__(self) + self.backendControllers = {} + + def getBackendControllers(self): + return self.backendControllers.values() + + def getBackendControllerByDomain(self, dom): + """Get the backend controller for a domain if there is one. + + @param dom: backend domain + @return: backend controller + """ + return self.backendControllers.get(dom) + + def getBackendController(self, dom): + """Get the backend controller for a domain, creating + if necessary. + + @param dom: backend domain + @return: backend controller + """ + b = self.getBackendControllerByDomain(dom) + if b is None: + b = self.createBackendController(dom) + self.backendControllers[b.dom] = b + return b + + def createBackendController(self, dom): + """Create a backend controller. Define in a subclass. + + @param dom: backend domain + @return: backend controller + """ + raise NotImplementedError() + + def delBackendController(self, ctrlr): + """Remove a backend controller. + + @param ctrlr: backend controller + """ + if ctrlr.dom in self.backendControllers: + del self.backendControllers[ctrlr.dom] + + def backendControllerClosed(self, ctrlr): + """Callback called when a backend is closed. + """ + self.delBackendController(ctrlr) + + def createBackendInterface(self, ctrl, dom, handle): + """Create a backend interface. Define in a subclass. + + @param ctrl: frontend controller + @param dom: backend domain + @return: backend interface + """ + raise NotImplementedError() -class BackendController(CtrlMsgRcvr): +class BackendController(Controller): """Abstract class for a backend device controller attached to a domain. - @ivar controller: frontend controller - @type controller: Controller - @ivar dom: domain + @ivar factory: backend controller factory + @type factory: BackendControllerFactory + @ivar dom: backend domain @type dom: int @ivar channel: channel to the domain @type channel: Channel """ - def __init__(self, controller, dom, handle): + def __init__(self, factory, dom): CtrlMsgRcvr.__init__(self) - self.controller = controller + self.factory = factory self.dom = int(dom) - self.handle = handle self.channel = None + self.backendInterfaces = {} def close(self): self.lostChannel() def lostChannel(self): self.deregisterChannel() - self.controller.backendClosed(self) + self.backend.backendClosed(self) + + def registerInterface(self, intf): + key = intf.getInterfaceKey() + self.backendInterfaces[key] = intf + + def deregisterInterface(self, intf): + key = intf.getInterfaceKey() + if key in self.backendInterfaces: + del self.backendInterfaces[key] + + def getInterface(self, dom, handle): + key = (dom, handle) + return self.backendInterfaces.get(key) + + + def createBackendInterface(self, ctrl, dom, handle): + """Create a backend interface. Define in a subclass. + + @param ctrl: controller + @param dom: backend domain + @param handle: backend handle + """ + raise NotImplementedError() + + +class BackendInterface: + """Abstract class for a domain's interface onto a backend controller. + """ + + def __init__(self, controller, dom, handle): + """ + + @param controller: front-end controller + @param dom: back-end domain + @param handle: back-end interface handle + """ + self.factory = controller.factory + self.controller = controller + self.dom = int(dom) + self.handle = handle + self.backend = self.getBackendController() + + def registerInterface(self): + self.backend.registerInterface(self) + + def getInterfaceKey(self): + return (self.controller.dom, self.handle) + + def getBackendController(self): + return self.factory.getBackendController(self.dom) + + def writeRequest(self, msg, response=None): + return self.backend.writeRequest(msg, response=response) + + def close(self): + self.backend.deregisterInterface(self) + self.controller.backendInterfaceClosed(self) class SplitController(Controller): """Abstract class for a device controller attached to a domain. - A SplitController manages a BackendController for each backend domain + A SplitController manages a BackendInterface for each backend domain it has at least one device for. """ def __init__(self, factory, dom): Controller.__init__(self, factory, dom) - self.backends = {} + self.backendInterfaces = {} self.backendHandle = 0 - def getBackends(self): - return self.backends.values() + def getBackendInterfaces(self): + return self.backendInterfaces.values() - def getBackendByHandle(self, handle): - for b in self.getBackends(): + def getBackendInterfaceByHandle(self, handle): + for b in self.getBackendInterfaces(): if b.handle == handle: return b return None - def getBackendByDomain(self, dom): - return self.backends.get(dom) + def getBackendInterfaceByDomain(self, dom): + return self.backendInterfaces.get(dom) - def getBackend(self, dom): - """Get the backend controller for a domain. + def getBackendInterface(self, dom): + """Get the backend interface for a domain. @param dom: domain @return: backend controller """ - b = self.getBackendByDomain(dom) + b = self.getBackendInterfaceByDomain(dom) if b is None: handle = self.backendHandle self.backendHandle += 1 - b = self.createBackend(dom, handle) - self.backends[b.dom] = b + b = self.factory.createBackendInterface(self, dom, handle) + b.registerInterface() + self.backendInterfaces[b.dom] = b return b - def createBackend(self, dom, handle): - """Create a backend controller. Define in a subclass. - - @param dom: domain - @param handle: controller handle - """ - raise NotImplementedError() - - def delBackend(self, ctrlr): + def delBackendInterface(self, ctrlr): """Remove a backend controller. @param ctrlr: backend controller """ - if ctrlr.dom in self.backends: - del self.backends[ctrlr.dom] + if ctrlr.dom in self.backendInterfaces: + del self.backendInterfaces[ctrlr.dom] - def backendClosed(self, ctrlr): + def backendInterfaceClosed(self, ctrlr): """Callback called when a backend is closed. """ - self.delBackend(ctrlr) + self.delBackendInterface(ctrlr) class Dev: """Abstract class for a device attached to a device controller. @@ -502,8 +623,8 @@ class SplitDev(Dev): Dev.__init__(self, idx, controller) self.backendDomain = 0 - def getBackend(self): - return self.controller.getBackend(self.backendDomain) + def getBackendInterface(self): + return self.controller.getBackendInterface(self.backendDomain) diff --git a/tools/python/xen/xend/server/domain.py b/tools/python/xen/xend/server/domain.py index 6d7ed8d83b..5ed26c7ca2 100644 --- a/tools/python/xen/xend/server/domain.py +++ b/tools/python/xen/xend/server/domain.py @@ -10,30 +10,14 @@ class DomainControllerFactory(controller.ControllerFactory): """Factory for creating domain controllers. """ - def createInstance(self, dom): + def createController(self, dom): """Create a domain controller. dom domain returns domain controller """ - d = DomainController(self, dom) - self.addInstance(d) - return d - - def getInstanceByDom(self, dom): - """Get a domain controller for a domain, creating if necessary. - - dom domain - - returns domain controller - """ - for inst in self.instances.values(): - if inst.dom == dom: - return inst - inst = self.createInstance(dom) - return inst - + return DomainController(self, dom) class DomainController(controller.Controller): """Generic controller for a domain. diff --git a/tools/python/xen/xend/server/netif.py b/tools/python/xen/xend/server/netif.py index 864f6ebd2d..a36dab1de2 100755 --- a/tools/python/xen/xend/server/netif.py +++ b/tools/python/xen/xend/server/netif.py @@ -19,11 +19,11 @@ import controller from messages import * class NetifBackendController(controller.BackendController): - """Handler for the 'back-end' channel to a device driver domain. + """Handler for the 'back-end' channel to a network device driver domain. """ - def __init__(self, ctrl, dom, handle): - controller.BackendController.__init__(self, ctrl, dom, handle) + def __init__(self, ctrl, dom): + controller.BackendController.__init__(self, ctrl, dom) self.addMethod(CMSG_NETIF_BE, CMSG_NETIF_BE_DRIVER_STATUS_CHANGED, self.recv_be_driver_status_changed) @@ -33,33 +33,56 @@ class NetifBackendController(controller.BackendController): val = unpackMsg('netif_be_driver_status_changed_t', msg) status = val['status'] -class NetifControllerFactory(controller.ControllerFactory): +class NetifBackendInterface(controller.BackendInterface): + """Handler for the 'back-end' channel to a network device driver domain + on behalf of a front-end domain. + + Each network device is handled separately, so we add no functionality + here. + """ + + pass + +class NetifControllerFactory(controller.SplitControllerFactory): """Factory for creating network interface controllers. """ def __init__(self): - controller.ControllerFactory.__init__(self) + controller.SplitControllerFactory.__init__(self) - def createInstance(self, dom, recreate=0): - """Create or find the network interface controller for a domain. + def createController(self, dom): + """Create a network interface controller for a domain. @param dom: domain - @param recreate: if true this is a recreate (xend restarted) @return: netif controller """ - netif = self.getInstanceByDom(dom) - if netif is None: - netif = NetifController(self, dom) - self.addInstance(netif) - return netif + return NetifController(self, dom) + + def createBackendController(self, dom): + """Create a network device backend controller. + + @param dom: backend domain + @return: backend controller + """ + return NetifBackendController(self, dom) + + def createBackendInterface(self, ctrl, dom, handle): + """Create a network device backend interface. + + @param ctrl: controller + @param dom: backend domain + @param handle: interface handle + @return: backend interface + """ + return NetifBackendInterface(ctrl, dom, handle) def getDomainDevices(self, dom): - """Get the network device controllers for a domain. + """Get the network devices for a domain. @param dom: domain @return: netif controller list """ - netif = self.getInstanceByDom(dom) + netif = self.getControllerByDom(dom) return (netif and netif.getDevices()) or [] def getDomainDevice(self, dom, vif): @@ -69,7 +92,7 @@ class NetifControllerFactory(controller.ControllerFactory): @param vif: virtual interface index @return: NetDev """ - netif = self.getInstanceByDom(dom) + netif = self.getControllerByDom(dom) return (netif and netif.getDevice(vif)) or None class NetDev(controller.SplitDev): @@ -179,7 +202,7 @@ class NetDev(controller.SplitDev): { 'domid' : self.controller.dom, 'netif_handle' : self.vif, 'mac' : self.mac }) - self.getBackend().writeRequest(msg, response=d) + self.getBackendInterface().writeRequest(msg, response=d) return d def respond_be_create(self, msg): @@ -193,6 +216,7 @@ class NetDev(controller.SplitDev): """ def cb_destroy(val): self.send_be_destroy() + self.getBackendInterface().close() log.debug("Destroying vif domain=%d vif=%d", self.controller.dom, self.vif) self.vifctl('down') d = self.send_be_disconnect() @@ -203,7 +227,7 @@ class NetDev(controller.SplitDev): msg = packMsg('netif_be_disconnect_t', { 'domid' : self.controller.dom, 'netif_handle' : self.vif }) - self.getBackend().writeRequest(msg, response=d) + self.getBackendInterface().writeRequest(msg, response=d) return d def send_be_destroy(self, response=None): @@ -211,7 +235,7 @@ class NetDev(controller.SplitDev): { 'domid' : self.controller.dom, 'netif_handle' : self.vif }) self.controller.delDevice(self.vif) - self.getBackend().writeRequest(msg, response=response) + self.getBackendInterface().writeRequest(msg, response=response) def recv_fe_interface_connect(self, val, req): if not req: return @@ -224,7 +248,7 @@ class NetDev(controller.SplitDev): 'rx_shmem_frame' : val['rx_shmem_frame'] }) d = defer.Deferred() d.addCallback(self.respond_be_connect) - self.getBackend().writeRequest(msg, response=d) + self.getBackendInterface().writeRequest(msg, response=d) def respond_be_connect(self, msg): val = unpackMsg('netif_be_connect_t', msg) @@ -260,9 +284,6 @@ class NetifController(controller.SplitController): self.recv_fe_interface_connect) self.registerChannel() - def createBackend(self, dom, handle): - return NetifBackendController(self, dom, handle) - def sxpr(self): val = ['netif', ['dom', self.dom]] return val -- 2.30.2